import { ITypeEntity } from '@/types/modules/superType/types';
import { PATH_CONFIG } from '../utils/source-path';

/**
 * 文件类型配置接口
 */
export interface FileTypeConfig {
  /** 文件类型标识 */
  type: ITypeEntity['type'];
  /** 文件扩展名 */
  extension: string;
  /** 显示名称 */
  displayName: string;
  /** 描述信息 */
  description?: string;
  /** 图标配置 */
  icon: {
    /** 颜色 */
    color: string;
    /** SVG 图标内容 */
    svg: string;
  };
  /** 默认存储目录 */
  defaultPath: string;
  /** 禁止存在的目录列表 */
  forbiddenPaths?: string[];
  /** 允许存在的目录列表 (如果设置，则只能在这些目录创建) */
  allowedPaths?: string[];
  /** 编辑器组件名称 */
  defaultShowVi?: boolean;
  defaultShowCode?: boolean;
  editorComponent?: string;
  editorProps?: Record<string, any>;
  editorComponentProjectId?: string;
  /** 语言类型 (用于代码高亮) */
  language?: string;
  /** 默认模板内容 */
  defaultTemplate?: string | (() => string);
  /** 文件验证器 */
  validator?: (content: string) => { valid: boolean; error?: string };
  /** 文件转换器 */
  transformer?: {
    /** 从源码转换为存储格式 */
    fromSource?: (source: string) => any;
    /** 从存储格式转换为源码 */
    toSource?: (data: any) => string;
  };
  /** 是否支持版本控制 */
  versionControl?: boolean;
  /** 是否支持搜索 */
  searchable?: boolean;
  /** 文件大小限制 (字节) */
  maxSize?: number;

  /** AI 提示词配置 */
  aiPrompt?: {
    /** 文件类型的详细说明（告诉 AI 这个文件是什么） */
    description: string;
    /** 文件格式说明（如：XML格式的Draw.io文件） */
    format?: string;
    /** 使用场景和用途 */
    usage?: string;
    /** 创建规则和约束 */
    creationRules?: string[];
    /** 编辑建议 */
    editingTips?: string[];
    /** 注意事项 */
    warnings?: string[];
    /** 示例内容或模板说明 */
    examples?: string[];
  };

  /** 自定义属性 */
  customProps?: {
    /** 自定义节点渲染器（用于项目面板） */
    nodeRenderer?: (
      resourceTree: any,
      props: any,
      typeItem: any,
      typeStore: any,
      folderPath: string,
    ) => any;

    /** 节点渲染配置 */
    nodeConfig?: {
      /** 是否显示类型标签 */
      showTypeLabel?: boolean;
      /** 自定义样式类名 */
      className?: string;
      /** 自定义工具提示 */
      tooltip?: string;
      /** 是否可编辑 */
      editable?: boolean;
      /** 是否可删除 */
      deletable?: boolean;
      /** 自定义渲染函数 */
      displayRender?: (typeItem: ITypeEntity) => { title: string; description: string };
    };

    /** 其他自定义属性 */
    [key: string]: any;
  };
  /** 实体创建钩子函数 */
  entityHooks?: {
    /** 创建实体前的钩子 */
    beforeCreate?: (options: any, config: FileTypeConfig) => any;
    /** 创建实体后的钩子 */
    afterCreate?: (entity: ITypeEntity, options: any, config: FileTypeConfig) => ITypeEntity;
    /** 自定义语言推断 */
    inferLanguage?: (content: string, options: any, config: FileTypeConfig) => string;
    /** 自定义数据解析 */
    parseData?: (content: string, options: any, config: FileTypeConfig) => any;
    /** 自定义默认值生成 */
    generateDefaults?: (options: any, config: FileTypeConfig) => Partial<ITypeEntity>;
  };
}

/**
 * 文件类型注册表
 */
export const FILE_TYPE_REGISTRY: Record<string, FileTypeConfig> = {
  // 现有类型
  // vo: {
  //   type: 'vo',
  //   extension: 'm.ts',
  //   displayName: '数据模型',
  //   icon: 'DatabaseOutlined',
  //   defaultPath: '/types',
  //   allowedPaths: ['/types', '/pages', '/components', '/modules'],
  //   editorComponent: 'TypeEditor',
  //   language: 'typescript',
  //   versionControl: true,
  //   searchable: true,
  //   customProps: {
  //     group: 'data',
  //     category: 'model',
  //   },
  //   entityHooks: {
  //     generateDefaults: (options, config) => ({
  //       language: 'typescript',
  //       data: {
  //         fields: [],
  //         interfaces: [],
  //         types: [],
  //       },
  //     }),
  //     afterCreate: (entity, options, config) => {
  //       console.log(`创建了新的数据模型: ${entity.name}`);
  //       return entity;
  //     },
  //   },
  // },

  // api: {
  //   type: 'api',
  //   extension: 'api.ts',
  //   displayName: '接口文档',
  //   icon: 'ApiOutlined',
  //   defaultPath: '/apis',
  //   allowedPaths: ['/apis', '/pages', '/components', '/modules'],
  //   editorComponent: 'ApiEditor',
  //   language: 'typescript',
  //   versionControl: true,
  //   searchable: true,
  //   customProps: {
  //     group: 'code',
  //     category: 'api',
  //   },
  //   entityHooks: {
  //     generateDefaults: (options, config) => ({
  //       language: 'typescript',
  //       data: {
  //         method: 'GET',
  //         path: `/${options.name || 'new-api'}`,
  //         description: options.desc || '新建API接口',
  //         parameters: [],
  //         responses: {
  //           200: { description: '成功' },
  //         },
  //       },
  //     }),
  //     beforeCreate: (options, config) => {
  //       // API 创建前的预处理
  //       if (!options.name) {
  //         options.name = `api_${Date.now()}`;
  //       }
  //       return options;
  //     },
  //     afterCreate: (entity, options, config) => {
  //       console.log(`创建了新的API: ${entity.name}`);
  //       return entity;
  //     },
  //   },
  // },

  // cloud_function: {
  //   type: 'cloud_function',
  //   extension: 'node.ts',
  //   displayName: '云函数',
  //   icon: 'CloudServerOutlined',
  //   defaultPath: '/cloud_functions',
  //   allowedPaths: ['/cloud_functions', '/pages', '/modules'],
  //   editorComponent: 'CloudFunctionEditor',
  //   language: 'typescript',
  //   versionControl: true,
  //   searchable: true,
  //   maxSize: 1024 * 1024, // 1MB
  //   customProps: {
  //     group: 'code',
  //     category: 'function',
  //   },
  // },

  // action: {
  //   type: 'action',
  //   extension: 'util.ts',
  //   displayName: '工具函数',
  //   icon: 'FunctionOutlined',
  //   defaultPath: '/utils',
  //   allowedPaths: ['/utils', '/pages', '/components', '/modules'],
  //   editorComponent: 'ActionEditor',
  //   language: 'typescript',
  //   versionControl: true,
  //   searchable: true,
  //   customProps: {
  //     group: 'code',
  //     category: 'function',
  //   },
  // },

  // code: {
  //   type: 'code',
  //   extension: 'md',
  //   displayName: 'Markdown文档',
  //   icon: 'FileMarkdownOutlined',
  //   defaultPath: '/docs',
  //   allowedPaths: ['/docs', '/pages', '/components', '/modules'],
  //   editorComponent: 'MarkdownEditor',
  //   language: 'markdown',
  //   versionControl: true,
  //   searchable: true,
  //   defaultTemplate: '# 新建文档\n\n请在这里编写内容...',
  //   customProps: {
  //     group: 'document',
  //     category: 'text',
  //   },
  // },

  // 新增类型
  // flow: {
  //   type: 'flow',
  //   extension: 'flow',
  //   displayName: '流程图',
  //   icon: 'PartitionOutlined',
  //   defaultPath: '/docs',
  //   allowedPaths: ['/docs', '/pages'],
  //   forbiddenPaths: ['/apis', '/cloud_functions'],
  //   editorComponent: 'FlowEditor',
  //   language: 'json',
  //   versionControl: true,
  //   searchable: false,
  //   maxSize: 512 * 1024, // 512KB
  //   defaultTemplate: () =>
  //     JSON.stringify(
  //       {
  //         nodes: [
  //           {
  //             id: 'start',
  //             type: 'start',
  //             position: { x: 100, y: 100 },
  //             data: { label: '开始' },
  //           },
  //         ],
  //         edges: [],
  //         viewport: { x: 0, y: 0, zoom: 1 },
  //       },
  //       null,
  //       2,
  //     ),
  //   validator: (content: string) => {
  //     try {
  //       const data = JSON.parse(content);
  //       if (!Array.isArray(data.nodes) || !Array.isArray(data.edges)) {
  //         return { valid: false, error: '流程图数据格式错误：缺少 nodes 或 edges 数组' };
  //       }
  //       return { valid: true };
  //     } catch (error) {
  //       return { valid: false, error: '无效的 JSON 格式' };
  //     }
  //   },
  //   customProps: {
  //     group: 'document',
  //     category: 'diagram',
  //   },
  //   entityHooks: {
  //     generateDefaults: (options, config) => ({
  //       language: 'json',
  //       data: {
  //         nodes: [
  //           {
  //             id: 'start',
  //             type: 'start',
  //             position: { x: 100, y: 100 },
  //             data: { label: options.name || '开始' },
  //           },
  //         ],
  //         edges: [],
  //         viewport: { x: 0, y: 0, zoom: 1 },
  //       },
  //     }),
  //     parseData: (content, options, config) => {
  //       try {
  //         return JSON.parse(content);
  //       } catch {
  //         return config.entityHooks?.generateDefaults?.(options, config)?.data;
  //       }
  //     },
  //     afterCreate: (entity, options, config) => {
  //       console.log(`创建了新的流程图: ${entity.name}`);
  //       return entity;
  //     },
  //   },
  // },

  draw: {
    type: 'draw',
    extension: 'draw',
    displayName: '流程图',
    description: '使用 Draw.io 创建的流程图、架构图等可视化图表文件',
    icon: {
      color: '#00a3ff',
      svg: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M12 2L2 7L12 12L22 7L12 2Z"/><path d="M2 17L12 22L22 17" stroke="currentColor" stroke-width="2" fill="none"/><path d="M2 12L12 17L22 12" stroke="currentColor" stroke-width="2" fill="none"/></svg>'
    },
    defaultPath: PATH_CONFIG.DOCS,
    allowedPaths: [PATH_CONFIG.DOCS, PATH_CONFIG.PAGES, PATH_CONFIG.MODULES],
    forbiddenPaths: [PATH_CONFIG.APIS, PATH_CONFIG.CLOUD_FUNCTIONS, PATH_CONFIG.TYPES],
    editorComponent: 'DrawIoEditor',
    defaultShowVi: true,
    defaultShowCode: false,
    editorComponentProjectId: '63a55a9168a86a319f690a04',
    language: 'xml',
    versionControl: true,
    searchable: false,
    maxSize: 1024 * 1024, // 1MB

    aiPrompt: {
      description:
        '流程图文件是使用 Draw.io 创建的可视化图表，虽然文件扩展名是 .draw，但实际内容是 XML 格式的 Draw.io 专用格式',
      format: 'XML 格式的 Draw.io 文件，包含 <mxfile> 根元素和 <diagram> 子元素',
      usage:
        '用于创建流程图、架构图、UML图、网络拓扑图等各种可视化图表，支持业务流程设计和系统架构展示',
      creationRules: [
        '文件必须以 .draw 扩展名结尾',
        '只能存放在 /docs、/pages、/modules 目录下',
        '禁止存放在 /apis、/cloud_functions、/types 目录',
        '文件名建议使用中文描述，如：用户注册流程.draw',
      ],
      editingTips: [
        '使用 Draw.io 编辑器进行可视化编辑',
        '支持拖拽方式创建图形元素',
        '建议为图表添加标题和说明文字',
      ],
      warnings: ['大型复杂图表可能影响加载性能', '注意文件大小限制，复杂图表建议分解为多个文件'],
      examples: [
        '用户注册流程.draw - 展示用户注册的完整流程',
        '系统架构图.draw - 展示系统的整体架构设计',
      ],
    },
    customProps: {
      group: 'visual',
      category: 'diagram',
      supportedFormats: ['mxfile', 'drawio'],
      nodeConfig: {
        showTypeLabel: true,
        tooltip: '双击编辑流程图',
        editable: true,
        deletable: true,
        className: 'draw-node',
        displayRender: (typeItem: ITypeEntity) => {
          return {
            title: typeItem.name,
            description: typeItem.desc,
          };
        },
      },
    },
    entityHooks: {
      beforeCreate(options) {
        if (!options.name) {
          options.name = `流程画布_${Date.now()}`;
        }
        options.source = '';
        return options;
      },
    },
    // validator: (content: string) => {
    //   try {
    //     const data = JSON.parse(content);
    //     if (!Array.isArray(data.elements) || !data.canvas) {
    //       return { valid: false, error: '绘图数据格式错误：缺少 elements 数组或 canvas 对象' };
    //     }
    //     return { valid: true };
    //   } catch (error) {
    //     return { valid: false, error: '无效的 JSON 格式' };
    //   }
    // },
  },

  flow: {
    type: 'flow',
    extension: 'flow',
    displayName: '协作画布',
    description: '使用 ReactFlow 创建的协作画布，支持节点拖拽、连线和实时协作',
    icon: {
      color: '#6366f1',
      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="3" width="18" height="18" rx="2" ry="2"/><line x1="9" y1="9" x2="15" y2="9"/><line x1="9" y1="15" x2="15" y2="15"/></svg>'
    },
    defaultPath: PATH_CONFIG.DOCS,
    allowedPaths: [PATH_CONFIG.DOCS, PATH_CONFIG.PAGES, PATH_CONFIG.MODULES],
    forbiddenPaths: [PATH_CONFIG.APIS, PATH_CONFIG.CLOUD_FUNCTIONS, PATH_CONFIG.TYPES],
    editorComponent: 'ReactFlowEditor',
    defaultShowVi: true,
    defaultShowCode: false,
    editorComponentProjectId: '63a55a9168a86a319f690a04',
    language: 'json',
    versionControl: true,
    searchable: false,
    maxSize: 2 * 1024 * 1024, // 2MB

    aiPrompt: {
      description:
        '协作画布文件是使用 ReactFlow 创建的可视化协作工具，文件扩展名是 .flow，实际内容是 JSON 格式的 ReactFlow 数据',
      format: 'JSON 格式的 ReactFlow 文件，包含 nodes、edges、viewport 等核心数据结构',
      usage:
        '用于创建协作画布、流程设计、系统架构图、业务流程图等，支持多人实时协作和节点间的连线关系',
      creationRules: [
        '文件必须以 .flow 扩展名结尾',
        '只能存放在 /docs、/pages、/modules 目录下',
        '禁止存放在 /apis、/cloud_functions、/types 目录',
        '文件名建议使用中文描述，如：业务流程设计.flow',
      ],
      editingTips: [
        '使用 ReactFlow 编辑器进行可视化编辑',
        '支持拖拽方式创建和连接节点',
        '支持多种节点类型：文档、数据模型、API、云函数等',
        '可以通过右键菜单添加新节点',
        '支持画布缩放和平移操作',
      ],
      warnings: [
        '大型画布可能影响加载性能，建议合理控制节点数量',
        '注意文件大小限制，复杂画布建议分解为多个文件',
        '协作时注意避免同时编辑同一区域',
      ],
      examples: [
        '项目架构图.flow - 展示项目的整体架构设计',
        '业务流程图.flow - 展示业务处理流程',
        '数据流图.flow - 展示数据在系统中的流转',
      ],
    },
    defaultTemplate: () =>
      JSON.stringify(
        {
          nodes: [
            {
              id: 'welcome-node',
              type: 'default',
              position: { x: 250, y: 100 },
              data: {
                label: '欢迎使用协作画布',
                description: '拖拽节点到画布开始设计',
              },
            },
          ],
          edges: [],
          viewport: { x: 0, y: 0, zoom: 1 },
        },
        null,
        2,
      ),
    validator: (content: string) => {
      try {
        const data = JSON.parse(content);
        if (!Array.isArray(data.nodes) || !Array.isArray(data.edges)) {
          return { valid: false, error: '协作画布数据格式错误：缺少 nodes 或 edges 数组' };
        }
        if (!data.viewport || typeof data.viewport !== 'object') {
          return { valid: false, error: '协作画布数据格式错误：缺少 viewport 对象' };
        }
        return { valid: true };
      } catch (error) {
        return { valid: false, error: '无效的 JSON 格式' };
      }
    },
    customProps: {
      group: 'visual',
      category: 'canvas',
      supportedFormats: ['reactflow', 'json'],
      nodeConfig: {
        showTypeLabel: true,
        tooltip: '双击编辑协作画布',
        editable: true,
        deletable: true,
        className: 'flow-node',
        displayRender: (typeItem: ITypeEntity) => {
          return {
            title: typeItem.name,
            description: typeItem.desc || '协作画布',
          };
        },
      },
    },
    entityHooks: {
      beforeCreate(options) {
        if (!options.name) {
          options.name = `协作画布_${Date.now()}`;
        }
        // 设置默认的 JSON 数据到 source 字段
        if (!options.source) {
          options.source = JSON.stringify(
            {
              nodes: [
                {
                  id: 'welcome-node',
                  type: 'default',
                  position: { x: 250, y: 100 },
                  data: {
                    label: options.name || '协作画布',
                    description: '拖拽节点到画布开始设计',
                  },
                },
              ],
              edges: [],
              viewport: { x: 0, y: 0, zoom: 1 },
            },
            null,
            2,
          );
        }
        return options;
      },
      parseData: (content) => {
        try {
          const data = JSON.parse(content);
          return {
            nodeCount: data.nodes?.length || 0,
            edgeCount: data.edges?.length || 0,
            viewport: data.viewport,
            lastModified: new Date().toISOString(),
          };
        } catch {
          return {
            nodeCount: 0,
            edgeCount: 0,
            viewport: { x: 0, y: 0, zoom: 1 },
            lastModified: new Date().toISOString(),
          };
        }
      },
      afterCreate: (entity) => {
        console.log(`创建了新的协作画布: ${entity.name}`);
        return entity;
      },
    },
  },

  // 通用代码文件类型
  typescript: {
    type: 'typescript',
    extension: 'ts',
    displayName: 'TypeScript 文件',
    description: 'TypeScript 源代码文件，支持类型检查和现代 JavaScript 特性',
    icon: {
      color: '#3178c6',
      svg: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M9.4 16.6L4.8 12l4.6-4.6L8 6l-6 6 6 6 1.4-1.4zm5.2 0l4.6-4.6-4.6-4.6L16 6l6 6-6 6-1.4-1.4z"/></svg>'
    },
    defaultPath: PATH_CONFIG.SRC,
    allowedPaths: [
      PATH_CONFIG.SRC,
      PATH_CONFIG.PAGES,
      PATH_CONFIG.COMPONENTS,
      PATH_CONFIG.MODULES,
      PATH_CONFIG.UTILS,
      PATH_CONFIG.TYPES,
      '/hooks',
    ],
    editorComponent: 'CodeEditor',
    defaultShowVi: false,
    defaultShowCode: true,
    language: 'typescript',
    versionControl: true,
    searchable: true,
    maxSize: 1024 * 1024, // 1MB

    aiPrompt: {
      description:
        'TypeScript 文件是带有类型注解的 JavaScript 超集，提供静态类型检查和更好的开发体验',
      format: 'TypeScript 源代码格式，支持类型注解、接口、泛型等特性',
      usage: '用于编写类型安全的 JavaScript 代码，包括组件、工具函数、类型定义等',
      creationRules: [
        '文件必须以 .ts 扩展名结尾',
        '可以存放在 /src、/pages、/components、/modules、/utils、/types、/hooks 目录下',
        '建议使用有意义的文件名，如：userService.ts',
      ],
      editingTips: [
        '使用 TypeScript 类型注解提高代码质量',
        '合理使用接口和类型别名',
        '利用泛型提高代码复用性',
        '遵循 TypeScript 最佳实践',
      ],
      warnings: ['注意类型定义的准确性', '避免使用 any 类型', '确保导入导出的正确性'],
      examples: [
        'userService.ts - 用户相关的服务函数',
        'types.ts - 类型定义文件',
        'utils.ts - 通用工具函数',
      ],
    },
    customProps: {
      group: 'code',
      category: 'typescript',
      nodeConfig: {
        showTypeLabel: true,
        tooltip: '双击编辑 TypeScript 文件',
        editable: true,
        deletable: true,
        className: 'typescript-node',
      },
    },
    entityHooks: {
      beforeCreate(options) {
        if (!options.name) {
          options.name = `typescript_${Date.now()}`;
        }
        if (!options.source) {
          options.source = '// TypeScript 文件\n\nexport {};\n';
        }
        return options;
      },
    },
  },

  javascript: {
    type: 'javascript',
    extension: 'js',
    displayName: 'JavaScript 文件',
    description: 'JavaScript 源代码文件，支持现代 ES6+ 语法特性',
    icon: {
      color: '#f7df1e',
      svg: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M3 3h18v18H3V3zm4.73 15.04c.4.85 1.19 1.55 2.54 1.55 1.5 0 2.53-.8 2.53-2.55v-5.78h-1.7V17c0 .86-.35 1.08-.9 1.08-.58 0-.82-.4-1.09-.87l-1.38.8zm5.98-.18c.5.98 1.51 1.73 3.09 1.73 1.6 0 2.8-.83 2.8-2.36 0-1.41-.81-2.04-2.25-2.66l-.42-.18c-.73-.31-1.04-.52-1.04-1.02 0-.41.31-.73.81-.73s.89.2 1.2.73l1.31-.87c-.55-.96-1.33-1.33-2.51-1.33-1.51 0-2.48.96-2.48 2.23 0 1.38.81 2.03 2.03 2.55l.42.18c.78.34 1.24.55 1.24 1.13 0 .48-.45.83-1.15.83-.83 0-1.31-.43-1.67-1.03l-1.38.8z"/></svg>'
    },
    defaultPath: PATH_CONFIG.SRC,
    allowedPaths: [
      PATH_CONFIG.SRC,
      PATH_CONFIG.PAGES,
      PATH_CONFIG.COMPONENTS,
      PATH_CONFIG.MODULES,
      PATH_CONFIG.UTILS,
      '/scripts',
    ],
    editorComponent: 'CodeEditor',
    defaultShowVi: false,
    defaultShowCode: true,
    language: 'javascript',
    versionControl: true,
    searchable: true,
    maxSize: 1024 * 1024, // 1MB

    aiPrompt: {
      description: 'JavaScript 文件是动态编程语言源代码，支持函数式和面向对象编程',
      format: 'JavaScript 源代码格式，支持 ES6+ 现代语法特性',
      usage: '用于编写客户端和服务端 JavaScript 代码，包括组件、工具函数、脚本等',
      creationRules: [
        '文件必须以 .js 扩展名结尾',
        '可以存放在 /src、/pages、/components、/modules、/utils、/scripts 目录下',
        '建议使用有意义的文件名，如：userHelper.js',
      ],
      editingTips: [
        '使用现代 ES6+ 语法特性',
        '合理使用模块化导入导出',
        '注意变量作用域和闭包',
        '遵循 JavaScript 最佳实践',
      ],
      warnings: ['注意类型转换和比较', '避免全局变量污染', '确保异步操作的正确处理'],
      examples: [
        'userHelper.js - 用户相关的辅助函数',
        'config.js - 配置文件',
        'utils.js - 通用工具函数',
      ],
    },
    customProps: {
      group: 'code',
      category: 'javascript',
      nodeConfig: {
        showTypeLabel: true,
        tooltip: '双击编辑 JavaScript 文件',
        editable: true,
        deletable: true,
        className: 'javascript-node',
      },
    },
    entityHooks: {
      beforeCreate(options) {
        if (!options.name) {
          options.name = `javascript_${Date.now()}`;
        }
        if (!options.source) {
          options.source = '// JavaScript 文件\n\n';
        }
        return options;
      },
    },
  },

  text: {
    type: 'text',
    extension: 'txt',
    displayName: '文本文件',
    description: '纯文本文件，支持各种文本内容编辑',
    icon: {
      color: '#666666',
      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14,2 14,8 20,8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/><polyline points="10,9 9,9 8,9"/></svg>'
    },
    defaultPath: PATH_CONFIG.DOCS,
    allowedPaths: [
      PATH_CONFIG.DOCS,
      PATH_CONFIG.SRC,
      PATH_CONFIG.PAGES,
      PATH_CONFIG.COMPONENTS,
      PATH_CONFIG.MODULES,
      PATH_CONFIG.UTILS,
      PATH_CONFIG.CONFIG,
    ],
    editorComponent: 'CodeEditor',
    defaultShowVi: false,
    defaultShowCode: true,
    language: 'text',
    versionControl: true,
    searchable: true,
    maxSize: 512 * 1024, // 512KB

    aiPrompt: {
      description: '文本文件是纯文本格式的文件，不包含任何格式化信息，适用于各种文本内容',
      format: '纯文本格式，不包含任何特殊格式化标记',
      usage: '用于存储配置信息、日志、说明文档、数据文件等各种文本内容',
      creationRules: [
        '文件必须以 .txt 扩展名结尾',
        '可以存放在任何允许的目录下',
        '建议使用有意义的文件名，如：配置说明.txt',
      ],
      editingTips: [
        '支持任意文本内容编辑',
        '注意文件编码格式（建议使用 UTF-8）',
        '可以用于临时记录和备注',
      ],
      warnings: ['注意文件大小限制', '避免存储敏感信息'],
      examples: [
        '配置说明.txt - 系统配置的说明文档',
        '更新日志.txt - 版本更新记录',
        '备注.txt - 临时备注和说明',
      ],
    },
    customProps: {
      group: 'document',
      category: 'text',
      nodeConfig: {
        showTypeLabel: true,
        tooltip: '双击编辑文本文件',
        editable: true,
        deletable: true,
        className: 'text-node',
      },
    },
    entityHooks: {
      beforeCreate(options) {
        if (!options.name) {
          options.name = `文本文件_${Date.now()}`;
        }
        if (!options.source) {
          options.source = '';
        }
        return options;
      },
    },
  },

  sql: {
    type: 'sql',
    extension: 'sql',
    displayName: 'SQL 文件',
    description: 'SQL 数据库脚本文件，支持各种数据库查询和操作语句',
    icon: {
      color: '#336791',
      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"/><path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"/></svg>'
    },
    defaultPath: PATH_CONFIG.DATABASE,
    allowedPaths: [PATH_CONFIG.DATABASE, PATH_CONFIG.SRC, '/scripts', '/migrations'],
    editorComponent: 'CodeEditor',
    defaultShowVi: false,
    defaultShowCode: true,
    language: 'sql',
    versionControl: true,
    searchable: true,
    maxSize: 1024 * 1024, // 1MB

    aiPrompt: {
      description: 'SQL 文件包含数据库查询语句、存储过程、触发器等数据库相关的脚本代码',
      format: 'SQL 语句格式，支持各种数据库方言（MySQL、PostgreSQL、SQLite 等）',
      usage: '用于数据库查询、数据迁移、存储过程定义、数据库初始化等',
      creationRules: [
        '文件必须以 .sql 扩展名结尾',
        '可以存放在 /database、/src、/scripts、/migrations 目录下',
        '建议使用有意义的文件名，如：用户表创建.sql',
      ],
      editingTips: [
        '使用标准 SQL 语法编写',
        '注意不同数据库的语法差异',
        '合理使用注释说明复杂查询',
        '遵循 SQL 编码规范',
      ],
      warnings: ['注意 SQL 注入安全问题', '谨慎使用 DROP、DELETE 等危险操作', '确保语法正确性'],
      examples: [
        '用户表创建.sql - 创建用户表的 DDL 语句',
        '数据查询.sql - 复杂的数据查询语句',
        '数据迁移.sql - 数据库迁移脚本',
      ],
    },
    customProps: {
      group: 'database',
      category: 'sql',
      nodeConfig: {
        showTypeLabel: true,
        tooltip: '双击编辑 SQL 文件',
        editable: true,
        deletable: true,
        className: 'sql-node',
      },
    },
    entityHooks: {
      beforeCreate(options) {
        if (!options.name) {
          options.name = `sql_${Date.now()}`;
        }
        if (!options.source) {
          options.source = '-- SQL 文件\n\n';
        }
        return options;
      },
    },
  },

  json: {
    type: 'json',
    extension: 'json',
    displayName: 'JSON 文件',
    description: 'JSON 数据文件，支持结构化数据存储和配置管理',
    icon: {
      color: '#f39c12',
      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 12h18m-9-9v18"/><circle cx="12" cy="12" r="9"/></svg>'
    },
    defaultPath: PATH_CONFIG.CONFIG,
    allowedPaths: [PATH_CONFIG.CONFIG, '/data', PATH_CONFIG.SRC, PATH_CONFIG.DOCS, '/scripts'],
    editorComponent: 'CodeEditor',
    defaultShowVi: false,
    defaultShowCode: true,
    language: 'json',
    versionControl: true,
    searchable: true,
    maxSize: 512 * 1024, // 512KB

    aiPrompt: {
      description: 'JSON 文件是轻量级的数据交换格式，使用键值对结构存储数据',
      format: 'JSON (JavaScript Object Notation) 格式，使用严格的语法规则',
      usage: '用于配置文件、数据存储、API 响应、设置参数等结构化数据场景',
      creationRules: [
        '文件必须以 .json 扩展名结尾',
        '可以存放在 /config、/data、/src、/docs、/scripts 目录下',
        '建议使用有意义的文件名，如：app-config.json',
      ],
      editingTips: [
        '使用标准 JSON 语法，注意引号和逗号',
        '所有字符串必须使用双引号',
        '不支持注释，可以使用特殊字段如 "_comment"',
        '注意数据类型：字符串、数字、布尔值、数组、对象、null',
      ],
      warnings: [
        '严格遵循 JSON 语法规则，语法错误会导致解析失败',
        '避免循环引用',
        '注意文件大小，大型 JSON 文件可能影响性能',
      ],
      examples: [
        'app-config.json - 应用程序配置文件',
        'data.json - 静态数据文件',
        'package.json - 项目依赖配置',
      ],
    },
    validator: (content: string) => {
      try {
        JSON.parse(content);
        return { valid: true };
      } catch (error) {
        return { valid: false, error: `JSON 格式错误: ${error.message}` };
      }
    },
    customProps: {
      group: 'data',
      category: 'config',
      nodeConfig: {
        showTypeLabel: true,
        tooltip: '双击编辑 JSON 文件',
        editable: true,
        deletable: true,
        className: 'json-node',
      },
    },
    entityHooks: {
      beforeCreate(options) {
        if (!options.name) {
          options.name = `config_${Date.now()}`;
        }
        if (!options.source) {
          options.source = '{\n  \n}';
        }
        return options;
      },
      parseData: (content) => {
        try {
          const data = JSON.parse(content);
          return {
            format: 'json',
            type: 'config',
            keys: Object.keys(data).length,
            structure:
              typeof data === 'object' && data !== null
                ? Array.isArray(data)
                  ? 'array'
                  : 'object'
                : typeof data,
          };
        } catch {
          return {
            format: 'json',
            type: 'config',
            keys: 0,
            structure: 'invalid',
          };
        }
      },
    },
  },

  // // 示例：Markdown 文档类型
  // markdown: {
  //   type: 'code',
  //   extension: 'md',
  //   displayName: 'Markdown 文档',
  //   description: 'Markdown 格式的文档文件，支持富文本编辑和预览',
  //   icon: 'FileTextOutlined',
  //   defaultPath: '/docs',
  //   allowedPaths: ['/docs', '/pages', '/modules'],
  //   forbiddenPaths: ['/apis', '/cloud_functions'],
  //   editorComponent: 'MarkdownEditor',
  //   language: 'markdown',
  //   versionControl: true,
  //   searchable: true,
  //   maxSize: 512 * 1024, // 512KB

  //   aiPrompt: {
  //     description: 'Markdown 文档是轻量级标记语言文件，使用 .md 扩展名，支持富文本格式和代码高亮',
  //     format: 'Markdown 标记语言格式，使用纯文本编写，通过特殊符号实现格式化',
  //     usage: '用于编写项目文档、API说明、用户手册、技术规范等各种文档内容',
  //     creationRules: [
  //       '文件必须以 .md 扩展名结尾',
  //       '可以存放在 /docs、/pages、/modules 目录下',
  //       '禁止存放在 /apis、/cloud_functions 目录',
  //       '文件大小不能超过 512KB',
  //       '建议使用有意义的文件名，如：API接口文档.md',
  //     ],
  //     editingTips: [
  //       '使用 # 创建标题层级',
  //       '使用 **粗体** 和 *斜体* 强调文本',
  //       '使用 ``` 代码块展示代码',
  //       '使用 - 或 * 创建无序列表',
  //       '使用 [链接文字](URL) 创建链接',
  //       '支持表格、图片、引用等丰富格式',
  //     ],
  //     warnings: [
  //       '注意 Markdown 语法的正确性',
  //       '避免使用过于复杂的嵌套结构',
  //       '图片链接建议使用相对路径',
  //     ],
  //     examples: [
  //       'API接口文档.md - 详细的接口说明文档',
  //       '项目说明.md - 项目的整体介绍和使用指南',
  //       '开发规范.md - 团队开发规范和约定',
  //     ],
  //   },
  //   customProps: {
  //     group: 'document',
  //     category: 'text',
  //     supportedFormats: ['md', 'markdown'],
  //     nodeConfig: {
  //       showTypeLabel: true,
  //       tooltip: '双击编辑 Markdown 文档',
  //       editable: true,
  //       deletable: true,
  //       className: 'markdown-node',
  //     },
  //   },
  //   entityHooks: {
  //     beforeCreate(options) {
  //       if (!options.name) {
  //         options.name = `文档_${Date.now()}`;
  //       }
  //       if (!options.source) {
  //         options.source = '# 新建文档\n\n请在这里编写内容...';
  //       }
  //     },
  //     parseData: (content) => {
  //       // 提取 Markdown 标题作为描述
  //       const titleMatch = content.match(/^#\s+(.+)$/m);
  //       return {
  //         title: titleMatch ? titleMatch[1] : '未命名文档',
  //         content: content,
  //         wordCount: content.length,
  //       };
  //     },
  //   },
  // },

  // diagram: {
  //   type: 'diagram',
  //   extension: 'diagram',
  //   displayName: '图表',
  //   icon: 'BarChartOutlined',
  //   defaultPath: '/docs',
  //   allowedPaths: ['/docs', '/pages'],
  //   forbiddenPaths: ['/apis', '/cloud_functions'],
  //   editorComponent: 'DiagramEditor',
  //   language: 'markdown',
  //   versionControl: true,
  //   searchable: true,
  //   maxSize: 256 * 1024, // 256KB
  //   defaultTemplate: () =>
  //     JSON.stringify(
  //       {
  //         type: 'mermaid',
  //         content: `graph TD
  //   A[开始] --> B{判断条件}
  //   B -->|是| C[执行操作]
  //   B -->|否| D[结束]
  //   C --> D`,
  //       },
  //       null,
  //       2,
  //     ),
  //   validator: (content: string) => {
  //     try {
  //       const data = JSON.parse(content);
  //       if (!data.type || !data.content) {
  //         return { valid: false, error: '图表数据格式错误：缺少 type 或 content 字段' };
  //       }
  //       return { valid: true };
  //     } catch (error) {
  //       return { valid: false, error: '无效的 JSON 格式' };
  //     }
  //   },
  //   customProps: {
  //     group: 'document',
  //     category: 'diagram',
  //   },
  // },

  // config: {
  //   type: 'config',
  //   extension: 'json',
  //   displayName: '配置文件',
  //   icon: 'SettingOutlined',
  //   defaultPath: '/config',
  //   allowedPaths: ['/config', '/pages', '/components', '/modules'],
  //   forbiddenPaths: ['/docs'],
  //   editorComponent: 'JsonEditor',
  //   language: 'json',
  //   versionControl: true,
  //   searchable: true,
  //   defaultTemplate: '{}',
  //   validator: (content: string) => {
  //     try {
  //       JSON.parse(content);
  //       return { valid: true };
  //     } catch (error) {
  //       return { valid: false, error: '无效的 JSON 格式' };
  //     }
  //   },
  //   customProps: {
  //     group: 'data',
  //     category: 'config',
  //   },
  // },
};

/**
 * 文件类型管理器
 */
export class FileTypeManager {
  private static instance: FileTypeManager;
  private registry = new Map<string, FileTypeConfig>();

  private constructor() {
    // 初始化注册表
    Object.entries(FILE_TYPE_REGISTRY).forEach(([key, config]) => {
      this.registry.set(key, config);
    });
  }

  static getInstance(): FileTypeManager {
    if (!FileTypeManager.instance) {
      FileTypeManager.instance = new FileTypeManager();
    }
    return FileTypeManager.instance;
  }

  /**
   * 注册文件类型
   */
  register(config: FileTypeConfig): void {
    this.registry.set(config.type, config);
  }

  /**
   * 获取文件类型配置
   */
  getConfig(type: string): FileTypeConfig | undefined {
    return this.registry.get(type);
  }

  /**
   * 根据扩展名获取文件类型
   */
  getTypeByExtension(extension: string): FileTypeConfig | undefined {
    for (const config of this.registry.values()) {
      if (config.extension === extension) {
        return config;
      }
    }
    return undefined;
  }

  /**
   * 获取所有文件类型
   */
  getAllTypes(): FileTypeConfig[] {
    return Array.from(this.registry.values());
  }

  /**
   * 检查路径是否允许创建指定类型的文件
   */
  isPathAllowed(type: string, path: string): boolean {
    const config = this.getConfig(type);
    if (!config) return false;

    // 检查禁止路径
    if (config.forbiddenPaths?.some((forbidden) => path.startsWith(forbidden))) {
      return false;
    }

    // 检查允许路径
    if (config.allowedPaths?.length) {
      return config.allowedPaths.some((allowed) => path.startsWith(allowed));
    }

    return true;
  }

  /**
   * 验证文件内容
   */
  validateContent(type: string, content: string): { valid: boolean; error?: string } {
    const config = this.getConfig(type);
    if (!config) return { valid: false, error: '未知的文件类型' };

    // 检查文件大小
    if (config.maxSize && content.length > config.maxSize) {
      return {
        valid: false,
        error: `文件大小超过限制 (${Math.round(config.maxSize / 1024)}KB)`,
      };
    }

    // 执行自定义验证
    if (config.validator) {
      return config.validator(content);
    }

    return { valid: true };
  }

  /**
   * 获取默认模板
   */
  getDefaultTemplate(type: string): string {
    const config = this.getConfig(type);
    if (!config?.defaultTemplate) return '';

    return typeof config.defaultTemplate === 'function'
      ? config.defaultTemplate()
      : config.defaultTemplate;
  }

  /**
   * 根据文件路径获取文件类型配置
   */
  getConfigByPath(filePath: string): FileTypeConfig | null {
    const allConfigs = this.getAllTypes();

    for (const config of allConfigs) {
      if (filePath.endsWith(`.${config.extension}`)) {
        return config;
      }
    }

    return null;
  }

  /**
   * 检查文件是否需要通过 validateAndUpdateType 处理
   * 只处理配置中明确定义的新文件类型，不影响原有的硬编码类型
   */
  shouldValidateAsType(filePath: string): boolean {
    const config = this.getConfigByPath(filePath);
    if (!config) return false;

    // 排除原有的硬编码文件类型，避免重复处理
    const legacyExtensions = ['.node.ts', '.m.ts', '.api.ts', '.util.ts', '.md', '.css'];
    const isLegacyType = legacyExtensions.some((ext) => filePath.endsWith(ext));

    if (isLegacyType) {
      return false; // 原有类型由硬编码逻辑处理
    }

    // 只处理配置中新定义的文件类型
    const newTypesThatNeedValidation = [
      'draw',
      'flow',
      'diagram',
      'workflow',
      'config',
      'typescript',
      'javascript',
      'text',
      'sql',
      'json',
      // 可以在这里添加更多新的文件类型
    ];

    return newTypesThatNeedValidation.includes(config.type);
  }

  /**
   * 检查文件是否需要 CSS 处理
   */
  shouldValidateAsCSS(filePath: string): boolean {
    return filePath.endsWith('.css');
  }

  /**
   * 获取所有需要特殊处理的文件扩展名
   */
  getValidationExtensions(): string[] {
    const allConfigs = this.getAllTypes();
    const typesThatNeedValidation = [
      'vo',
      'api',
      'cloud_function',
      'action',
      'code',
      'draw',
      'flow',
      'diagram',
      'typescript',
      'javascript',
      'text',
      'sql',
      'json',
    ];

    return allConfigs
      .filter((config) => typesThatNeedValidation.includes(config.type))
      .map((config) => config.extension);
  }

  /**
   * 根据文件路径推断文件类型
   */
  inferTypeFromPath(filePath: string): ITypeEntity['type'] | null {
    const config = this.getConfigByPath(filePath);
    return config ? config.type : null;
  }
}

export default FileTypeManager.getInstance();
